<?php

Raise::load('core.RaiseNumericCollection');

/**
 * TestCoreRaiseNumericCollection
 * Testing unit of 'phpraise/core/RaiseNumericCollection.php'
 *
 * @author Sam-Mauris Yong <hellclanner at live dot com>
 * @license http://www.opensource.org/licenses/bsd-license New BSD License
 * @package Raise.UnitTest.Test
 */
class TestCoreRaiseNumericCollection extends RaiseTest {

    public static function testRaiseNumericCollection(){
        self::assertClassExists('RaiseNumericCollection');
        self::assertClassExtends('RaiseNumericCollection', 'RaiseCollection');
    }

    public static function testMinMax(){
        $x = new RaiseNumericCollection();
        $x->add(200);
        $x->add(203.1);
        $x->add(1032.5);
        $x->add(30);

        self::assertStrictEqual($x->max(), 1032.5);
        self::assertStrictEqual($x->min(), 30);

        $x = new RaiseNumericCollection();
        $x->add(200);
        $x->add(203.1);
        $x->add(1032.5);
        $x->add(1032.4);
        $x->add(1032.5);
        $x->add(30);
        $x->add(30);
        $x->add(30);
        $x->add(30);

        self::assertStrictEqual($x->max(), 1032.5);
        self::assertStrictEqual($x->min(), 30);
    }

    public static function testSum(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(4);
        $x->add(8);
        $x->add(16);
        $x->add(1024);

        self::assertStrictEqual($x->sum(), 1054);
    }

    public static function testMean(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(4);
        $x->add(8);
        $x->add(16);
        $x->add(1024);

        self::assertStrictEqual($x->mean(), 210.8);
        self::assertStrictEqual($x->mean(), $x->sum()/$x->count());
    }

    public static function testCount(){
        $x = new RaiseNumericCollection();
        self::assertStrictEqual($x->count(), 0);
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(4);
        $x->add(8);
        $x->add(16);
        $x->add(1024);

        self::assertStrictEqual($x->count(), 5);
    }

    public static function testMode(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(8);
        $x->add(1024);
        $x->add(1024);
        $x->add(4);
        $x->add(8);
        $x->add(4);
        $x->add(16);
        $x->add(1024);
        $x->add(2);

        self::assertStrictEqual($x->mode(), 1024);
    }

    public static function testMedian(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(8);
        $x->add(1024);
        $x->add(1024);
        $x->add(4);
        $x->add(8);
        $x->add(4);
        $x->add(16);
        $x->add(1024);
        $x->add(2);

        self::assertStrictEqual($x->median(), 8);
    }

    public static function testRange(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(8);
        $x->add(1024);
        $x->add(1024);
        $x->add(4);
        $x->add(8);
        $x->add(4);
        $x->add(16);
        $x->add(1024);
        $x->add(2);

        self::assertStrictEqual($x->range(), 1022);
        self::assertStrictEqual($x->range(), $x->max() - $x->min());
    }

    public static function testProbability(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(8);
        $x->add(1024);
        $x->add(1024);
        $x->add(4);
        $x->add(8);
        $x->add(4);
        $x->add(16);
        $x->add(1024);
        $x->add(2);

        self::assertStrictEqual($x->probability(2), 0.2);
        self::assertStrictEqual($x->probability(1024), 0.3);
        self::assertStrictEqual($x->probability(4), 0.2);
        self::assertStrictEqual($x->probability(8), 0.2);
        self::assertStrictEqual($x->probability(16), 0.1);
    }

    public static function testSD(){
        $x = new RaiseNumericCollection();
        $x->add(2);
        $x->add(8);
        $x->add(1024);
        $x->add(1024);
        $x->add(4);
        $x->add(8);
        $x->add(4);
        $x->add(16);
        $x->add(1024);
        $x->add(2);

        self::assertEqual((string)$x->standardDeviation(), (string)466.39108053221);
        self::assertEqual((string)$x->standardDeviation(true), (string)491.61936495626);
    }

}
